/**
 * 聊天Store - 管理会话和聊天消息
 */
import { defineStore } from '../index'
import { syncChatData } from '../../api/chat'
import type { ChatMessageData, ChatMessageContent, ImageMessageContent, VoiceMessageContent } from '../../utils/WebSocket'
import { ws } from '../../utils/WebSocket'
import { request } from '@kit.BasicServicesKit'

// 导出语音消息内容类型，供其他模块使用
export type { VoiceMessageContent } from '../../utils/WebSocket'


// 候选人信息
export interface CandidateInfo {
  id: string
  name: string
  face: string
  unreadMsgCount: number
  birthday: string
  sex: number
}

// HR信息
export interface HrInfo {
  id: string
  name: string
  face: string
  unreadMsgCount: number
  companyName: string
  position: string
}

// 消息内容（使用 WebSocket 中的类型）
export type MessageContent = ChatMessageContent

// 消息接口（基于 ChatMessageData，添加服务器返回的 id 字段）
export interface Message {
  id: string                          // 服务器生成的消息ID
  sessionId: string                   // 会话ID
  senderId: string                    // 发送者ID
  receiveId: string                   // 接收者ID
  msgType: number                     // 消息类型
  content: ChatMessageContent | null  // 消息内容（允许 null）
  createTime: number                  // 消息发送时间
  loading?: boolean                   // 消息是否正在加载中（用于上传中的图片等）
  localPath?: string                  // 本地文件路径（用于图片、语音等）
}

// 会话详情
export interface SessionDetail {
  id: string
  candidateInfo: CandidateInfo
  hrInfo: HrInfo
  lastMsgTime: number
  lastMessage: Message | null
  curContactPositionId: string | null
}

// 同步请求项
interface SyncRequestItem {
  sessionId: string
  lastMessageTime: number
}

// 同步响应中的会话项
interface SyncSessionItem {
  sessionId: string
  sessionDetail: SessionDetail
  newMessages: Message[]
}

// 同步响应
interface SyncResponse {
  newSessions: SyncSessionItem[]
  updatedSessions: SyncSessionItem[]
}

// State类型
interface ChatState {
  // 求职者角色的会话列表（按 lastMsgTime 降序）
  candidateSessions: SessionDetail[]
  // 招聘者角色的会话列表（按 lastMsgTime 降序）
  hrSessions: SessionDetail[]
  // 求职者角色的聊天消息（按 sessionId 分组）暂不实现
  candidateMessages: Record<string, Message[]>
  // 招聘者角色的聊天消息（按 sessionId 分组）暂不实现
  hrMessages: Record<string, Message[]>
  // UI 刷新标志
  refreshFlag: number
  // 当前激活的会话ID（用于判断是否需要自动已读）
  activeSessionId: string
}

// Getters类型
interface ChatGetters {
  // 获取求职者角色的会话列表
  getCandidateSessions: (state: ChatState) => SessionDetail[]
  // 获取招聘者角色的会话列表
  getHrSessions: (state: ChatState) => SessionDetail[]
  // 获取指定会话的消息列表
  getSessionMessages: (state: ChatState) => (roleType: number, sessionId: string) => Message[]
}

// Actions类型
interface ChatActions {
  // 同步聊天数据
  syncChat: (roleType: number) => Promise<void>
  // 添加新会话
  addSession: (roleType: number, session: SessionDetail) => void
  // 更新会话
  updateSession: (roleType: number, session: SessionDetail) => void
  // 处理新消息
  handleNewMessage: (message: Message, roleType: number) => void
  // 添加消息到指定会话
  addMessages: (roleType: number, sessionId: string, messages: Message[]) => void
  // 添加单条消息到指定会话
  addMessage: (roleType: number, sessionId: string, message: Message) => void
  // 更新消息
  updateMessage: (roleType: number, sessionId: string, messageId: string, updates: Partial<Message>) => void
  // 下载图片并保存到本地
  downloadAndSaveImage: (imageUrl: string) => Promise<string>
  // 处理图片消息（下载图片到本地）
  handleImageMessage: (roleType: number, message: Message) => Promise<void>
  // 下载语音并保存到本地
  downloadAndSaveAudio: (audioUrl: string) => Promise<string>
  // 处理语音消息（下载语音到本地）
  handleVoiceMessage: (roleType: number, message: Message) => Promise<void>
  // 触发刷新
  triggerRefresh: () => void
  // 连接 WebSocket
  connectWebSocket: (token: string, roleType: number) => Promise<void>
  // 断开 WebSocket
  disconnectWebSocket: () => Promise<void>
  // 清空所有聊天数据
  clearAll: () => void
  // 标记会话为已读（清除未读数）
  markSessionAsRead: (roleType: number, sessionId: string) => void
  // 设置当前激活的会话ID
  setActiveSession: (sessionId: string) => void
  // 清除当前激活的会话ID
  clearActiveSession: () => void
}

/**
 * 聊天Store定义
 */
export const useChatStore = defineStore<ChatState, ChatGetters, ChatActions>({
  id: 'chat',
  
  // 状态
  state: () => ({
    candidateSessions: [],
    hrSessions: [],
    candidateMessages: {},
    hrMessages: {},
    refreshFlag: 0,
    activeSessionId: ''
  }),
  
  // 计算属性
  getters: {
    // 获取求职者角色的会话列表
    getCandidateSessions(state: ChatState): SessionDetail[] {
      return state.candidateSessions
    },
    
    // 获取招聘者角色的会话列表
    getHrSessions(state: ChatState): SessionDetail[] {
      return state.hrSessions
    },
    
    // 获取指定会话的消息列表
    getSessionMessages(state: ChatState) {
      return (roleType: number, sessionId: string): Message[] => {
        const messages = roleType === 1 ? state.candidateMessages : state.hrMessages
        return messages[sessionId] || []
      }
    }
  },
  
  // 方法
  actions: {
    /**
     * 同步聊天数据
     * @param roleType 角色类型 1-求职者 2-招聘者
     */
    async syncChat(roleType: number): Promise<void> {
      try {
        console.log(`[ChatStore] 开始同步聊天数据，角色: ${roleType}`)
        
        // 构建同步请求参数
        const sessions = roleType === 1 ? this.$state.candidateSessions : this.$state.hrSessions
        const messagesMap = roleType === 1 ? this.$state.candidateMessages : this.$state.hrMessages
        
        // 从本地消息列表中获取最新消息时间
        const syncRequest: SyncRequestItem[] = sessions.map(session => {
          const sessionMessages = messagesMap[session.id] || []
          let lastMessageTime = 0
          
          // 从消息列表中获取最新的消息时间
          if (sessionMessages.length > 0) {
            // 消息列表已按时间排序，取最后一条消息的时间
            lastMessageTime = sessionMessages[sessionMessages.length - 1].createTime
          }
          
          console.log(`[ChatStore] 会话 ${session.id}: 本地消息数=${sessionMessages.length}, 最新消息时间=${lastMessageTime}`)
          
          return {
            sessionId: session.id,
            lastMessageTime: lastMessageTime
          }
        })
        
        console.log(`[ChatStore] 本地会话数量: ${sessions.length}`)
        
        // 调用同步接口
        const response: SyncResponse = await syncChatData(roleType, syncRequest)
        
        console.log(`[ChatStore] 同步响应 - 新会话: ${response.newSessions.length}, 更新会话: ${response.updatedSessions.length}`)
        
        // 处理新会话
        if (response.newSessions && response.newSessions.length > 0) {
          response.newSessions.forEach((item, index) => {
            console.log(`[ChatStore] 处理新会话 #${index + 1}: sessionId=${item.sessionId}, newMessages数量=${item.newMessages?.length || 0}`)
            
            // 设置未读消息数（新消息数量）
            const newMessageCount = item.newMessages?.length || 0
            if (roleType === 1) {
              item.sessionDetail.hrInfo.unreadMsgCount = newMessageCount
            } else {
              item.sessionDetail.candidateInfo.unreadMsgCount = newMessageCount
            }
            
            // 添加会话
            this.addSession(roleType, item.sessionDetail)
            
            // 添加该会话的新消息
            if (item.newMessages && item.newMessages.length > 0) {
              console.log(`[ChatStore] 准备添加 ${item.newMessages.length} 条消息到会话 ${item.sessionId}`)
              this.addMessages(roleType, item.sessionId, item.newMessages)
              console.log(`[ChatStore] 会话 ${item.sessionId} 添加了 ${item.newMessages.length} 条消息，未读数: ${newMessageCount}`)
              
              // 处理图片消息和语音消息，下载到本地
              item.newMessages.forEach(msg => {
                if (msg.content?.type === 'IMAGE') {
                  this.handleImageMessage(roleType, msg)
                } else if (msg.content?.type === 'VOICE') {
                  this.handleVoiceMessage(roleType, msg)
                }
              })
              
              // 如果是当前激活的会话，立即标记为已读
              if (item.sessionId === this.$state.activeSessionId) {
                console.log(`[ChatStore] 会话 ${item.sessionId} 是当前激活会话，立即标记为已读`)
                this.markSessionAsRead(roleType, item.sessionId)
              }
            } else {
              console.log(`[ChatStore] 会话 ${item.sessionId} 没有新消息`)
            }
          })
          console.log(`[ChatStore] 添加了 ${response.newSessions.length} 个新会话`)
        }
        
        // 处理更新的会话（增量更新）
        if (response.updatedSessions && response.updatedSessions.length > 0) {
          response.updatedSessions.forEach(item => {
            // 设置未读消息数（新消息数量）
            const newMessageCount = item.newMessages?.length || 0
            if (roleType === 1) {
              item.sessionDetail.hrInfo.unreadMsgCount = newMessageCount
            } else {
              item.sessionDetail.candidateInfo.unreadMsgCount = newMessageCount
            }
            
            // 更新会话
            this.updateSession(roleType, item.sessionDetail)
            
            // 添加该会话的新消息
            if (item.newMessages && item.newMessages.length > 0) {
              this.addMessages(roleType, item.sessionId, item.newMessages)
              console.log(`[ChatStore] 会话 ${item.sessionId} 添加了 ${item.newMessages.length} 条新消息，未读数: ${newMessageCount}`)
              
              // 处理图片消息和语音消息，下载到本地
              item.newMessages.forEach(msg => {
                if (msg.content?.type === 'IMAGE') {
                  this.handleImageMessage(roleType, msg)
                } else if (msg.content?.type === 'VOICE') {
                  this.handleVoiceMessage(roleType, msg)
                }
              })
              
              // 如果是当前激活的会话，立即标记为已读
              if (item.sessionId === this.$state.activeSessionId) {
                console.log(`[ChatStore] 会话 ${item.sessionId} 是当前激活会话，立即标记为已读`)
                this.markSessionAsRead(roleType, item.sessionId)
              }
            }
          })
          console.log(`[ChatStore] 更新了 ${response.updatedSessions.length} 个会话`)
        }
        
        console.log(`[ChatStore] 聊天数据同步完成`)
      } catch (error) {
        console.error('[ChatStore] 同步聊天数据失败:', error)
        throw error
      }
    },
    
    /**
     * 添加新会话
     * @param roleType 角色类型 1-求职者 2-招聘者
     * @param session 会话详情
     */
    addSession(roleType: number, session: SessionDetail) {
      const sessions = roleType === 1 ? this.$state.candidateSessions : this.$state.hrSessions
      
      // 检查会话是否已存在
      const existingIndex = sessions.findIndex(s => s.id === session.id)
      if (existingIndex !== -1) {
        // 已存在，更新
        sessions[existingIndex] = session
      } else {
        // 不存在，添加
        sessions.push(session)
      }
      
      // 按 lastMsgTime 降序排序
      sessions.sort((a, b) => b.lastMsgTime - a.lastMsgTime)
      
      // 更新状态
      if (roleType === 1) {
        this.$state.candidateSessions = [...sessions]
      } else {
        this.$state.hrSessions = [...sessions]
      }
    },
    
    /**
     * 更新会话（增量更新）
     * @param roleType 角色类型 1-求职者 2-招聘者
     * @param session 会话详情
     */
    updateSession(roleType: number, session: SessionDetail) {
      const sessions = roleType === 1 ? this.$state.candidateSessions : this.$state.hrSessions
      
      // 查找现有会话
      const existingIndex = sessions.findIndex(s => s.id === session.id)
      if (existingIndex !== -1) {
        // 合并更新
        sessions[existingIndex] = {
          ...sessions[existingIndex],
          ...session
        }
        
        // 按 lastMsgTime 降序排序
        sessions.sort((a, b) => b.lastMsgTime - a.lastMsgTime)
        
        // 更新状态
        if (roleType === 1) {
          this.$state.candidateSessions = [...sessions]
        } else {
          this.$state.hrSessions = [...sessions]
        }
      } else {
        // 不存在，作为新会话添加
        this.addSession(roleType, session)
      }
    },
    
    /**
     * 处理新消息（WebSocket 推送）
     * @param message 消息对象
     * @param roleType 当前用户角色 1-求职者 2-招聘者
     */
    handleNewMessage(message: Message, roleType: number) {
      console.log(`[ChatStore] 处理新消息: sessionId=${message.sessionId}, id=${message.id}, roleType=${roleType}`)
      
      const sessions = roleType === 1 ? this.$state.candidateSessions : this.$state.hrSessions
      
      // 查找对应的会话
      const existingIndex = sessions.findIndex(s => s.id === message.sessionId)
      
      if (existingIndex !== -1) {
        // 会话已存在，更新最后一条消息和时间
        sessions[existingIndex].lastMessage = message
        sessions[existingIndex].lastMsgTime = message.createTime
        
        // 判断是否是当前激活的会话
        const isActiveSession = message.sessionId === this.$state.activeSessionId
        
        // 如果消息是别人发的，增加未读数（除非是当前激活的会话）
        const session = sessions[existingIndex]
        if (!isActiveSession) {
          if (roleType === 1) {
            // 求职者：判断是否是 HR 发的
            if (message.senderId === session.hrInfo.id) {
              session.hrInfo.unreadMsgCount = (session.hrInfo.unreadMsgCount || 0) + 1
              console.log(`[ChatStore] 会话 ${message.sessionId} 未读数 +1: ${session.hrInfo.unreadMsgCount}`)
            }
          } else {
            // 招聘者：判断是否是候选人发的
            if (message.senderId === session.candidateInfo.id) {
              session.candidateInfo.unreadMsgCount = (session.candidateInfo.unreadMsgCount || 0) + 1
              console.log(`[ChatStore] 会话 ${message.sessionId} 未读数 +1: ${session.candidateInfo.unreadMsgCount}`)
            }
          }
        } else {
          console.log(`[ChatStore] 会话 ${message.sessionId} 是当前激活会话，不增加未读数`)
        }
        
        // 重新排序（最新消息的会话排在前面）
        sessions.sort((a, b) => b.lastMsgTime - a.lastMsgTime)
        
        // 更新状态
        if (roleType === 1) {
          this.$state.candidateSessions = [...sessions]
        } else {
          this.$state.hrSessions = [...sessions]
        }
        
        // 将消息添加到该会话的消息列表中
        this.addMessage(roleType, message.sessionId, message)
        
        // 如果是图片或语音消息，下载到本地
        if (message.content?.type === 'IMAGE') {
          this.handleImageMessage(roleType, message)
        } else if (message.content?.type === 'VOICE') {
          this.handleVoiceMessage(roleType, message)
        }
        
        // 通过 AppStorage 通知 UI 刷新
        try {
          const currentRefreshFlag = AppStorage.get<number>('chatSessionsNeedsRefresh') || 0
          AppStorage.setOrCreate('chatSessionsNeedsRefresh', currentRefreshFlag + 1)
          console.log(`[ChatStore] 已触发 AppStorage 刷新: ${currentRefreshFlag} -> ${currentRefreshFlag + 1}`)
        } catch (e) {
          console.log('[ChatStore] 触发 AppStorage 刷新失败:', e)
        }
        
        console.log(`[ChatStore] 已更新会话 ${message.sessionId} 的最新消息`)
      } else {
        // 会话不存在，可能是新会话，需要重新同步
        console.log(`[ChatStore] 收到新会话 ${message.sessionId} 的消息，需要同步`)
        // 这里可以触发同步，或者等待下次同步
      }
    },
    
    /**
     * 添加消息到指定会话
     * @param roleType 角色类型 1-求职者 2-招聘者
     * @param sessionId 会话ID
     * @param messages 消息列表
     */
    addMessages(roleType: number, sessionId: string, messages: Message[]) {
      console.log(`[ChatStore] addMessages 调用: roleType=${roleType}, sessionId=${sessionId}, messages数量=${messages?.length || 0}`)
      
      if (!messages || messages.length === 0) {
        console.log(`[ChatStore] addMessages 跳过：消息为空`)
        return
      }
      
      const messagesMap = roleType === 1 ? this.$state.candidateMessages : this.$state.hrMessages
      console.log(`[ChatStore] 当前消息map的keys:`, Object.keys(messagesMap))
      
      // 获取当前会话的消息列表
      const currentMessages = messagesMap[sessionId] || []
      console.log(`[ChatStore] 会话 ${sessionId} 当前有 ${currentMessages.length} 条消息`)
      
      // 合并新消息，去重（根据消息ID）
      const existingIds = new Set(currentMessages.map(m => m.id))
      const newMessages = messages.filter(m => !existingIds.has(m.id))
      console.log(`[ChatStore] 去重后有 ${newMessages.length} 条新消息需要添加`)
      
      if (newMessages.length > 0) {
        // 合并并按时间排序
        const allMessages = [...currentMessages, ...newMessages]
        allMessages.sort((a, b) => a.createTime - b.createTime)
        
        // 更新状态
        if (roleType === 1) {
          this.$state.candidateMessages = {
            ...this.$state.candidateMessages,
            [sessionId]: allMessages
          }
          console.log(`[ChatStore] 已更新 candidateMessages, 新的keys:`, Object.keys(this.$state.candidateMessages))
        } else {
          this.$state.hrMessages = {
            ...this.$state.hrMessages,
            [sessionId]: allMessages
          }
          console.log(`[ChatStore] 已更新 hrMessages, 新的keys:`, Object.keys(this.$state.hrMessages))
        }
        
        console.log(`[ChatStore] 会话 ${sessionId} 添加了 ${newMessages.length} 条消息，总计 ${allMessages.length} 条`)
      } else {
        console.log(`[ChatStore] 会话 ${sessionId} 没有新消息需要添加（都已存在）`)
      }
    },
    
    /**
     * 添加单条消息到指定会话
     * @param roleType 角色类型 1-求职者 2-招聘者
     * @param sessionId 会话ID
     * @param message 消息对象
     */
    addMessage(roleType: number, sessionId: string, message: Message) {
      this.addMessages(roleType, sessionId, [message])
    },
    
    /**
     * 更新消息
     * @param roleType 角色类型 1-求职者 2-招聘者
     * @param sessionId 会话ID
     * @param messageId 消息ID
     * @param updates 要更新的字段
     */
    updateMessage(roleType: number, sessionId: string, messageId: string, updates: Partial<Message>) {
      const messagesMap = roleType === 1 ? this.$state.candidateMessages : this.$state.hrMessages
      const sessionMessages = messagesMap[sessionId] || []
      
      const messageIndex = sessionMessages.findIndex(m => m.id === messageId)
      if (messageIndex !== -1) {
        // 更新消息
        sessionMessages[messageIndex] = {
          ...sessionMessages[messageIndex],
          ...updates
        }
        
        // 更新状态
        if (roleType === 1) {
          this.$state.candidateMessages = {
            ...this.$state.candidateMessages,
            [sessionId]: [...sessionMessages]
          }
        } else {
          this.$state.hrMessages = {
            ...this.$state.hrMessages,
            [sessionId]: [...sessionMessages]
          }
        }
        
        console.log(`[ChatStore] 已更新消息 ${messageId}`)
      }
    },
    
    /**
     * 下载图片并保存到本地
     * @param imageUrl 图片URL
     * @returns 本地文件路径
     */
    async downloadAndSaveImage(imageUrl: string): Promise<string> {
      try {
        console.log('[ChatStore] 开始下载图片:', imageUrl)
        
        // 从 AppStorage 获取 UIAbilityContext
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        const context = AppStorage.get('context') as any
        if (!context) {
          throw new Error('Context 未找到，请确保在 EntryAbility 中已保存到 AppStorage')
        }
        
        // 生成唯一的文件名（使用时间戳 + 随机数）
        const fileName = `chat_img_${Date.now()}_${Math.floor(Math.random() * 10000)}.jpg`
        const localPath = context.filesDir + '/' + fileName
        
        console.log('[ChatStore] 目标保存路径:', localPath)
        
        // 创建下载任务并等待完成
        return new Promise((resolve, reject) => {
          request.downloadFile(context, {
            url: imageUrl,
            filePath: localPath
          }).then((downloadTask) => {
            // 监听下载完成
            downloadTask.on('complete', () => {
              console.log('[ChatStore] 图片下载成功:', localPath)
              resolve(localPath)
            })
            
            // 监听下载失败
            downloadTask.on('fail', (err) => {
              console.error('[ChatStore] 图片下载失败:', err)
              reject(err)
            })
          }).catch((err) => {
            console.error('[ChatStore] 创建下载任务失败:', err)
            reject(err)
          })
        })
      } catch (error) {
        console.error('[ChatStore] 下载图片异常:', error)
        throw error
      }
    },
    
    /**
     * 处理图片消息（下载图片到本地）
     * @param roleType 角色类型
     * @param message 图片消息
     */
    async handleImageMessage(roleType: number, message: Message): Promise<void> {
      if (message.content?.type !== 'IMAGE') {
        return
      }
      
      const imageContent = message.content as ImageMessageContent
      if (!imageContent.imageUrl) {
        return
      }
      
      try {
        // 下载图片到本地
        const localPath = await this.downloadAndSaveImage(imageContent.imageUrl)
        
        // 更新消息，添加本地路径
        this.updateMessage(roleType, message.sessionId, message.id, {
          localPath: localPath
        })
        
        console.log(`[ChatStore] 图片消息已保存到本地: ${localPath}`)
      } catch (error) {
        console.error('[ChatStore] 处理图片消息失败:', error)
      }
    },
    
    /**
     * 下载语音文件并保存到本地
     * @param audioUrl 语音URL
     * @returns 本地文件路径
     */
    async downloadAndSaveAudio(audioUrl: string): Promise<string> {
      try {
        console.log('[ChatStore] 开始下载语音:', audioUrl)
        
        // 从 AppStorage 获取 UIAbilityContext
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        const context = AppStorage.get('context') as any
        if (!context) {
          throw new Error('Context 未找到，请确保在 EntryAbility 中已保存到 AppStorage')
        }
        
        // 生成唯一的文件名（使用时间戳 + 随机数）
        const fileName = `chat_audio_${Date.now()}_${Math.floor(Math.random() * 10000)}.mp3`
        const localPath = context.filesDir + '/' + fileName
        
        console.log('[ChatStore] 目标保存路径:', localPath)
        
        // 创建下载任务并等待完成
        return new Promise((resolve, reject) => {
          request.downloadFile(context, {
            url: audioUrl,
            filePath: localPath
          }).then((downloadTask) => {
            // 监听下载完成
            downloadTask.on('complete', () => {
              console.log('[ChatStore] 语音下载成功:', localPath)
              resolve(localPath)
            })
            
            // 监听下载失败
            downloadTask.on('fail', (err) => {
              console.error('[ChatStore] 语音下载失败:', err)
              reject(err)
            })
          }).catch((err) => {
            console.error('[ChatStore] 创建下载任务失败:', err)
            reject(err)
          })
        })
      } catch (error) {
        console.error('[ChatStore] 下载语音异常:', error)
        throw error
      }
    },
    
    /**
     * 处理语音消息（下载语音到本地）
     * @param roleType 角色类型
     * @param message 语音消息
     */
    async handleVoiceMessage(roleType: number, message: Message): Promise<void> {
      if (message.content?.type !== 'VOICE') {
        return
      }
      
      const voiceContent = message.content as VoiceMessageContent
      if (!voiceContent.audioUrl) {
        return
      }
      
      try {
        // 下载语音到本地
        const localPath = await this.downloadAndSaveAudio(voiceContent.audioUrl)
        
        // 更新消息，添加本地路径
        this.updateMessage(roleType, message.sessionId, message.id, {
          localPath: localPath
        })
        
        console.log(`[ChatStore] 语音消息已保存到本地: ${localPath}`)
      } catch (error) {
        console.error('[ChatStore] 处理语音消息失败:', error)
      }
    },
    
    /**
     * 触发UI刷新
     */
    triggerRefresh() {
      this.$state.refreshFlag++
      console.log(`[ChatStore] 触发刷新标志: ${this.$state.refreshFlag}`)
    },
    
    /**
     * 连接 WebSocket 并监听消息
     * @param token 用户token
     * @param roleType 用户角色类型
     */
    async connectWebSocket(token: string, roleType: number): Promise<void> {
      if (!token) {
        console.log('[ChatStore] token 为空，跳过 WebSocket 连接')
        return
      }

      try {
        console.log('[ChatStore] 开始连接 WebSocket...')
        await ws.init(token)
        console.log('[ChatStore] WebSocket 连接初始化完成')
        
        // 监听聊天消息
        ws.on('chat', (messageData: Message) => {
          // 将收到的数据转为纯对象（避免代理对象问题）
          const message: Message = JSON.parse(JSON.stringify(messageData))
          console.log(`[ChatStore] 收到聊天消息: sessionId=${message.sessionId}, id=${message.id}`)
          
          // 处理新消息
          this.handleNewMessage(message, roleType)
        })
        
        console.log('[ChatStore] WebSocket 消息监听已设置')
      } catch (error) {
        console.error('[ChatStore] WebSocket 连接失败:', error)
      }
    },

    /**
     * 断开 WebSocket
     */
    async disconnectWebSocket(): Promise<void> {
      try {
        console.log('[ChatStore] 开始断开 WebSocket 连接...')
        await ws.disconnect()
        console.log('[ChatStore] WebSocket 断开连接完成')
      } catch (error) {
        console.error('[ChatStore] WebSocket 断开连接失败:', error)
      }
    },
    
    /**
     * 清空所有聊天数据
     */
    clearAll() {
      this.$state.candidateSessions = []
      this.$state.hrSessions = []
      this.$state.candidateMessages = {}
      this.$state.hrMessages = {}
      this.$state.refreshFlag = 0
      this.$state.activeSessionId = ''
    },
    
    /**
     * 标记会话为已读（清除未读数）
     * @param roleType 角色类型 1-求职者 2-招聘者
     * @param sessionId 会话ID
     */
    markSessionAsRead(roleType: number, sessionId: string) {
      const sessions = roleType === 1 ? this.$state.candidateSessions : this.$state.hrSessions
      const sessionIndex = sessions.findIndex(s => s.id === sessionId)
      
      if (sessionIndex !== -1) {
        const session = sessions[sessionIndex]
        if (roleType === 1) {
          if (session.hrInfo.unreadMsgCount > 0) {
            console.log(`[ChatStore] 标记会话 ${sessionId} 为已读，清除未读数: ${session.hrInfo.unreadMsgCount} -> 0`)
            session.hrInfo.unreadMsgCount = 0
          }
        } else {
          if (session.candidateInfo.unreadMsgCount > 0) {
            console.log(`[ChatStore] 标记会话 ${sessionId} 为已读，清除未读数: ${session.candidateInfo.unreadMsgCount} -> 0`)
            session.candidateInfo.unreadMsgCount = 0
          }
        }
        
        // 更新状态
        if (roleType === 1) {
          this.$state.candidateSessions = [...sessions]
        } else {
          this.$state.hrSessions = [...sessions]
        }
        
        // 通知 UI 刷新
        this.triggerRefresh()
        
        try {
          const currentRefreshFlag = AppStorage.get<number>('chatSessionsNeedsRefresh') || 0
          AppStorage.setOrCreate('chatSessionsNeedsRefresh', currentRefreshFlag + 1)
        } catch (e) {
          console.log('[ChatStore] 触发刷新失败:', e)
        }
      }
    },
    
    /**
     * 设置当前激活的会话ID
     * @param sessionId 会话ID
     */
    setActiveSession(sessionId: string) {
      console.log(`[ChatStore] 设置当前激活会话: ${sessionId}`)
      this.$state.activeSessionId = sessionId
    },
    
    /**
     * 清除当前激活的会话ID
     */
    clearActiveSession() {
      console.log(`[ChatStore] 清除当前激活会话: ${this.$state.activeSessionId}`)
      this.$state.activeSessionId = ''
    }
  },
  
  // 持久化配置
  persist: {
    enabled: true,
    key: 'chat_store',
    paths: ['candidateSessions', 'hrSessions', 'candidateMessages', 'hrMessages']
  }
})
